পাইথন অপারেটর মডিউল: ফাংশনাল প্রোগ্রামিংয়ের জন্য শক্তিশালী ইউটিলিটি

প্রোগ্রামিংয়ের জগতে, বিশেষ করে যখন ফাংশনাল প্রোগ্রামিং প্যারাডাইম গ্রহণ করা হয়, তখন পরিষ্কার, সংক্ষিপ্ত এবং পুনরায় ব্যবহারযোগ্য উপায়ে অপারেশন প্রকাশ করার ক্ষমতা অত্যন্ত গুরুত্বপূর্ণ। পাইথন, মূলত একটি অবজেক্ট-ওরিয়েন্টেড ভাষা হলেও, ফাংশনাল প্রোগ্রামিং শৈলীর জন্য শক্তিশালী সমর্থন সরবরাহ করে। এই সমর্থনের একটি গুরুত্বপূর্ণ, যদিও কখনও কখনও উপেক্ষিত, উপাদান হল operator মডিউল। এই মডিউলটি পাইথনের অভ্যন্তরীণ অপারেটরগুলির সাথে সম্পর্কিত দক্ষ ফাংশনগুলির একটি সংগ্রহ সরবরাহ করে, যা ল্যাম্বডা ফাংশনগুলির চমৎকার বিকল্প হিসাবে কাজ করে এবং কোডের পঠনযোগ্যতা ও কার্যকারিতা বাড়ায়।

operator মডিউল বোঝা

operator মডিউল এমন ফাংশন সংজ্ঞায়িত করে যা পাইথনের বিল্ট-ইন অপারেটরগুলির সমতুল্য অপারেশন সম্পাদন করে। উদাহরণস্বরূপ, operator.add(a, b) হল a + b এর সমতুল্য, এবং operator.lt(a, b) হল a < b এর সমতুল্য। এই ফাংশনগুলি প্রায়শই তাদের অপারেটর প্রতিরূপের চেয়ে বেশি দক্ষ হয়, বিশেষ করে কার্যকারিতা-সংবেদনশীল প্রেক্ষাপটে, এবং map(), filter(), এবং functools.reduce() এর মতো ফাংশনাল প্রোগ্রামিং কনস্ট্রাক্টগুলিতে এগুলি একটি গুরুত্বপূর্ণ ভূমিকা পালন করে।

সরাসরি অপারেটরের পরিবর্তে কেন আপনি operator মডিউলের একটি ফাংশন ব্যবহার করবেন? প্রাথমিক কারণগুলি হল:

• ফাংশনাল স্টাইল সামঞ্জস্যতা: পাইথনের অনেক উচ্চ-ক্রম ফাংশন (যেমন functools-এর ফাংশনগুলি) কলযোগ্য অবজেক্ট আশা করে। অপারেটর ফাংশনগুলি কলযোগ্য, যা একটি পৃথক ল্যাম্বডা ফাংশন সংজ্ঞায়িত করার প্রয়োজন ছাড়াই আর্গুমেন্ট হিসাবে পাস করার জন্য তাদের নিখুঁত করে তোলে।
• পঠনযোগ্যতা: নির্দিষ্ট জটিল পরিস্থিতিতে, জটিল ল্যাম্বডা এক্সপ্রেশনের চেয়ে নামযুক্ত অপারেটর ফাংশন ব্যবহার করা কখনও কখনও কোডের স্পষ্টতা উন্নত করতে পারে।
• কার্যকারিতা: নির্দিষ্ট অপারেশনগুলির জন্য, বিশেষ করে যখন লুপ বা উচ্চ-ক্রম ফাংশনগুলির মধ্যে বারবার কল করা হয়, তখন অপারেটর ফাংশনগুলি C-তে তাদের বাস্তবায়নের কারণে সামান্য কার্যকারিতা সুবিধা দিতে পারে।

মূল অপারেটর ফাংশন

operator মডিউলটিকে তারা যে ধরনের অপারেশন উপস্থাপন করে তা দ্বারা বিস্তৃতভাবে শ্রেণীবদ্ধ করা যেতে পারে। চলুন, কিছু সর্বাধিক ব্যবহৃত ফাংশনগুলি অন্বেষণ করা যাক।

গাণিতিক অপারেটর

এই ফাংশনগুলি স্ট্যান্ডার্ড গাণিতিক গণনা সম্পাদন করে। যখন আপনাকে অন্য ফাংশনে একটি গাণিতিক অপারেশন আর্গুমেন্ট হিসাবে পাস করতে হয় তখন এগুলি বিশেষভাবে কার্যকর হয়।

• operator.add(a, b): a + b এর সমতুল্য।
• operator.sub(a, b): a - b এর সমতুল্য।
• operator.mul(a, b): a * b এর সমতুল্য।
• operator.truediv(a, b): a / b (ট্রু ডিভিশন) এর সমতুল্য।
• operator.floordiv(a, b): a // b (ফ্লোর ডিভিশন) এর সমতুল্য।
• operator.mod(a, b): a % b (মডুলো) এর সমতুল্য।
• operator.pow(a, b): a ** b (এক্সপোনেনশিয়েশন) এর সমতুল্য।
• operator.neg(a): -a (ইউনারি নেগেশন) এর সমতুল্য।
• operator.pos(a): +a (ইউনারি পজিটিভ) এর সমতুল্য।
• operator.abs(a): abs(a) এর সমতুল্য।

উদাহরণ: functools.reduce এর সাথে operator.add ব্যবহার করা

ধরুন আপনাকে একটি তালিকার সমস্ত উপাদান যোগ করতে হবে। যদিও sum() হল সবচেয়ে পাইথনিক উপায়, একটি অপারেটর ফাংশন সহ reduce ব্যবহার করে এর উপযোগিতা প্রদর্শন করা হয়:

            import operator
from functools import reduce

numbers = [1, 2, 3, 4, 5]

# Using reduce with operator.add
total = reduce(operator.add, numbers)
print(f"The sum of {numbers} is: {total}") # Output: The sum of [1, 2, 3, 4, 5] is: 15

            

              
                Copy
              
            
          

এটি কার্যকরীভাবে এর সমতুল্য:

            total_lambda = reduce(lambda x, y: x + y, numbers)
print(f"Sum using lambda: {total_lambda}") # Output: Sum using lambda: 15

            

              
                Copy
              
            
          

operator.add সংস্করণটি প্রায়শই এর স্পষ্টতা এবং সম্ভাব্য কার্যকারিতা সুবিধার জন্য পছন্দ করা হয়।

তুলনামূলক অপারেটর

এই ফাংশনগুলি দুটি অপারেন্ডের মধ্যে তুলনা সম্পাদন করে।

• operator.lt(a, b): a < b (কম) এর সমতুল্য।
• operator.le(a, b): a <= b (কম বা সমান) এর সমতুল্য।
• operator.eq(a, b): a == b (সমান) এর সমতুল্য।
• operator.ne(a, b): a != b (সমান নয়) এর সমতুল্য।
• operator.ge(a, b): a >= b (বেশি বা সমান) এর সমতুল্য।
• operator.gt(a, b): a > b (বেশি) এর সমতুল্য।

উদাহরণ: একটি নির্দিষ্ট কী দ্বারা অভিধানগুলির একটি তালিকা সাজানো

ধরুন আপনার কাছে ব্যবহারকারীর প্রোফাইলগুলির একটি তালিকা রয়েছে, প্রতিটি একটি অভিধান দ্বারা প্রতিনিধিত্ব করা হয়েছে, এবং আপনি তাদের 'score' দ্বারা সাজাতে চান।

            import operator

users = [
    {'name': 'Alice', 'score': 85},
    {'name': 'Bob', 'score': 92},
    {'name': 'Charlie', 'score': 78}
]

# Sort users by score using operator.itemgetter
sorted_users = sorted(users, key=operator.itemgetter('score'))
print("Users sorted by score:")
for user in sorted_users:
    print(user)
# Output:
# Users sorted by score:
# {'name': 'Charlie', 'score': 78}
# {'name': 'Alice', 'score': 85}
# {'name': 'Bob', 'score': 92}

            

              
                Copy
              
            
          

এখানে, operator.itemgetter('score') হল একটি কলযোগ্য যা একটি অভিধান দেওয়া হলে, 'score' কী-এর সাথে সম্পর্কিত মানটি ফিরিয়ে দেয়। এটি key=lambda user: user['score'] লেখার চেয়ে পরিষ্কার এবং বেশি কার্যকর।

বুলিয়ান অপারেটর

এই ফাংশনগুলি লজিক্যাল অপারেশন সম্পাদন করে।

• operator.not_(a): not a এর সমতুল্য।
• operator.truth(a): যদি a সত্য হয় তাহলে True, অন্যথায় False ফিরিয়ে দেয়।
• operator.is_(a, b): a is b এর সমতুল্য।
• operator.is_not(a, b): a is not b এর সমতুল্য।

উদাহরণ: মিথ্যা মানগুলি ফিল্টার করা

আপনি operator.truth কে filter() এর সাথে ব্যবহার করে একটি ইটারেবল থেকে সমস্ত মিথ্যা মান (যেমন 0, None, খালি স্ট্রিং, খালি তালিকা) সরাতে পারেন।

            import operator

data = [1, 0, 'hello', '', None, [1, 2], []]

# Filter out falsy values using operator.truth
filtered_data = list(filter(operator.truth, data))
print(f"Original data: {data}")
print(f"Filtered data (truthy values): {filtered_data}")
# Output:
# Original data: [1, 0, 'hello', '', None, [1, 2], []]
# Filtered data (truthy values): [1, 'hello', [1, 2]]

            

              
                Copy
              
            
          

বিটওয়াইজ অপারেটর

এই ফাংশনগুলি পূর্ণসংখ্যার স্বতন্ত্র বিটগুলিতে কাজ করে।

• operator.and_(a, b): a & b এর সমতুল্য।
• operator.or_(a, b): a | b এর সমতুল্য।
• operator.xor(a, b): a ^ b এর সমতুল্য।
• operator.lshift(a, b): a << b এর সমতুল্য।
• operator.rshift(a, b): a >> b এর সমতুল্য।
• operator.invert(a): ~a এর সমতুল্য।

উদাহরণ: বিটওয়াইজ অপারেশন সম্পাদন করা

            import operator

a = 10 # Binary: 1010
b = 4  # Binary: 0100

print(f"a & b: {operator.and_(a, b)}") # Output: a & b: 0 (Binary: 0000)
print(f"a | b: {operator.or_(a, b)}")  # Output: a | b: 14 (Binary: 1110)
print(f"a ^ b: {operator.xor(a, b)}") # Output: a ^ b: 14 (Binary: 1110)
print(f"~a: {operator.invert(a)}")     # Output: ~a: -11

            

              
                Copy
              
            
          

সিকোয়েন্স এবং ম্যাপিং অপারেটর

এই ফাংশনগুলি সিকোয়েন্স (যেমন তালিকা, টুপল, স্ট্রিং) এবং ম্যাপিং (যেমন অভিধান) এর মধ্যে উপাদানগুলি অ্যাক্সেস করার জন্য কার্যকর।

• operator.getitem(obj, key): obj[key] এর সমতুল্য।
• operator.setitem(obj, key, value): obj[key] = value এর সমতুল্য।
• operator.delitem(obj, key): del obj[key] এর সমতুল্য।
• operator.len(obj): len(obj) এর সমতুল্য।
• operator.concat(a, b): a + b (স্ট্রিং বা তালিকার মতো সিকোয়েন্সের জন্য) এর সমতুল্য।
• operator.contains(obj, item): item in obj এর সমতুল্য।

operator.itemgetter: একটি শক্তিশালী টুল

সাজানোর উদাহরণে যেমনটি ইঙ্গিত করা হয়েছে, operator.itemgetter একটি বিশেষায়িত ফাংশন যা অবিশ্বাস্যভাবে কার্যকর। যখন এটি এক বা একাধিক আর্গুমেন্ট সহ কল করা হয়, তখন এটি একটি কলযোগ্য ফিরিয়ে দেয় যা তার অপারেন্ড থেকে সেই আইটেমগুলি নিয়ে আসে। যদি একাধিক আর্গুমেন্ট দেওয়া হয়, তবে এটি আনা আইটেমগুলির একটি টুপল ফিরিয়ে দেয়।

            import operator

# Fetching a single item
get_first_element = operator.itemgetter(0)
my_list = [10, 20, 30]
print(f"First element: {get_first_element(my_list)}") # Output: First element: 10

# Fetching multiple items
get_first_two = operator.itemgetter(0, 1)
print(f"First two elements: {get_first_two(my_list)}") # Output: First two elements: (10, 20)

# Fetching items from a dictionary
get_name_and_score = operator.itemgetter('name', 'score')
user_data = {'name': 'Alice', 'score': 85, 'city': 'New York'}
print(f"User info: {get_name_and_score(user_data)}") # Output: User info: ('Alice', 85)

            

              
                Copy
              
            
          

operator.itemgetter সাজানোর ক্ষেত্রে key আর্গুমেন্ট হিসাবে বা অন্যান্য ফাংশনে যখন একটি কী ফাংশন গ্রহণ করে, তখন এটি খুব কার্যকর হয়।

operator.attrgetter: অ্যাট্রিবিউট অ্যাক্সেস করা

itemgetter এর অনুরূপভাবে, operator.attrgetter একটি কলযোগ্য ফিরিয়ে দেয় যা তার অপারেন্ড থেকে অ্যাট্রিবিউট নিয়ে আসে। অবজেক্টের সাথে কাজ করার সময় এটি বিশেষভাবে সুবিধাজনক।

            import operator

class Product:
    def __init__(self, name, price):
        self.name = name
        self.price = price

products = [
    Product('Laptop', 1200),
    Product('Mouse', 25),
    Product('Keyboard', 75)
]

# Get all product names
get_name = operator.attrgetter('name')
product_names = [get_name(p) for p in products]
print(f"Product names: {product_names}") # Output: Product names: ['Laptop', 'Mouse', 'Keyboard']

# Sort products by price
sorted_products = sorted(products, key=operator.attrgetter('price'))
print("Products sorted by price:")
for p in sorted_products:
    print(f"- {p.name}: ${p.price}")
# Output:
# Products sorted by price:
# - Mouse: $25
# - Keyboard: $75
# - Laptop: $1200

            

              
                Copy
              
            
          

attrgetter ডট নোটেশন ব্যবহার করে নেস্টেড অবজেক্টের মাধ্যমে অ্যাট্রিবিউটগুলি অ্যাক্সেস করতে পারে। উদাহরণস্বরূপ, operator.attrgetter('address.city') একটি অবজেক্টের 'address' অ্যাট্রিবিউট থেকে 'city' অ্যাট্রিবিউট নিয়ে আসবে।

অন্যান্য দরকারী ফাংশন

• operator.methodcaller(name, *args, **kwargs): একটি কলযোগ্য ফিরিয়ে দেয় যা তার অপারেন্ডে name নামের পদ্ধতিটিকে কল করে। এটি itemgetter এবং attrgetter এর পদ্ধতিগত সমতুল্য।

উদাহরণ: একটি তালিকার অবজেক্টগুলিতে একটি পদ্ধতি কল করা

            import operator

class Greeter:
    def __init__(self, name):
        self.name = name

    def greet(self, message):
        return f"{self.name} says: {message}"

greeters = [Greeter('Alice'), Greeter('Bob')]

# Call the greet method on each Greeter object
call_greet = operator.methodcaller('greet', 'Hello from the operator module!')

greetings = [call_greet(g) for g in greeters]
print(greetings)
# Output: ['Alice says: Hello from the operator module!', 'Bob says: Hello from the operator module!']

            

              
                Copy
              
            
          

ফাংশনাল প্রোগ্রামিং প্রেক্ষাপটে operator মডিউল

পাইথনের বিল্ট-ইন ফাংশনাল প্রোগ্রামিং টুলস যেমন map(), filter(), এবং functools.reduce() এর সাথে ব্যবহার করা হলে operator মডিউলের প্রকৃত ক্ষমতা প্রকাশ পায়।

map() এবং operator

map(function, iterable, ...)` একটি ইটারেবলের প্রতিটি আইটেমে একটি ফাংশন প্রয়োগ করে এবং ফলাফলগুলির একটি ইটারেটর ফিরিয়ে দেয়। অপারেটর ফাংশনগুলি এর জন্য নিখুঁত।

            import operator

numbers = [1, 2, 3, 4, 5]

# Square each number using map and operator.mul
squared_numbers = list(map(lambda x: operator.mul(x, x), numbers)) # Can be simpler: list(map(operator.mul, numbers, numbers)) or list(map(pow, numbers, [2]*len(numbers)))
print(f"Squared numbers: {squared_numbers}") # Output: Squared numbers: [1, 4, 9, 16, 25]

# Add 10 to each number using map and operator.add
added_ten = list(map(operator.add, numbers, [10]*len(numbers)))
print(f"Numbers plus 10: {added_ten}") # Output: Numbers plus 10: [11, 12, 13, 14, 15]

            

              
                Copy
              
            
          

            import operator

salaries = [50000, 65000, 45000, 80000, 70000]

# Filter salaries greater than 60000
high_salaries = list(filter(operator.gt, salaries, [60000]*len(salaries)))
print(f"Salaries above 60000: {high_salaries}") # Output: Salaries above 60000: [65000, 80000, 70000]

# Filter even numbers using operator.mod and lambda (or a more complex operator function)
even_numbers = list(filter(lambda x: operator.eq(operator.mod(x, 2), 0), [1, 2, 3, 4, 5, 6]))
print(f"Even numbers: {even_numbers}") # Output: Even numbers: [2, 4, 6]

            

              
                Copy
              
            
          

            import operator
from functools import reduce

numbers = [2, 3, 4, 5]

# Calculate the product of numbers
product = reduce(operator.mul, numbers)
print(f"Product: {product}") # Output: Product: 120

# Find the maximum number
maximum = reduce(operator.gt, numbers)
print(f"Maximum: {maximum}") # This doesn't work as expected for max, need to use a lambda or custom function for max: 
# Using lambda for max:
maximum_lambda = reduce(lambda x, y: x if x > y else y, numbers)
print(f"Maximum (lambda): {maximum_lambda}") # Output: Maximum (lambda): 5
# Note: The max() built-in function is generally preferred for finding the maximum.

            

              
                Copy